/********************************************************************
 * 
 *      输入参数    char *str：需要截取的字段包
 *      #define     Start_WORD   截取字段的首部
 *      #define     End_WORD     截取字段的尾部
 *      返回值                   所截取出的字段    
 * 
 *		作用：在一段字符串中以某个字符位置开始，以某个字符位置结束，截取出中间的这部分字符
 * ******************************************************************/
#define Start_WORD "\"result\":\""      //根据具体的功能需要更改define
#define End_WORD '\"'
char Token_Buf_temp[512];char* get_Token(char *str)   
{
    char *p = NULL;
    char *q = NULL;
    static int16_t i = 0;
    if ((p = strstr(str, Start_WORD)) != NULL)        //首先查找是否有关键字段
    {
        q = p - 1 + strlen(Start_WORD);            /* 跳过关键字部分 */

        while (*(++q)!= End_WORD)  //以查找到的起始字符串+跳过关键字部分 为初始地址查找"做为结束地址并复制下来
        {
            Token_Buf_temp[i]=*q;
            ++i;
        }
        printf("%.*s\r\n", strlen(Token_Buf_temp), Token_Buf_temp);
    }
    return Token_Buf_temp;   
}

/*******************************************************************************
*字符串转十六进制
*
*******************************************************************************/
void StrToHex(char *pbDest, char *pbSrc, int nLen)
{
  char h1,h2;
  char s1,s2;
  int i;
  for (i=0; i<nLen/2; i++)
  {
    h1 = pbSrc[2*i];
    h2 = pbSrc[2*i+1];

    s1 = toupper(h1) - 0x30; //toupper 转换为大写字母
    if (s1 > 9)
        s1 -= 7;
    s2 = toupper(h2) - 0x30;
    if (s2 > 9)
        s2 -= 7;

    pbDest[i] = s1*16 + s2;
  }
}

/*******************************************************************************
*       十六进制转字符
*   //效果：十六进制"0x13 0xAA 0x02"，转为字符串"13AAA2"。
*******************************************************************************/
void HexToStr(char *pszDest, char *pbSrc, int nLen)
{
   char    ddl, ddh;
   for (int i = 0; i < nLen; i++)
   {
      ddh = 48 + pbSrc[i] / 16;
      ddl = 48 + pbSrc[i] % 16;
      if (ddh > 57) ddh = ddh + 7;
      if (ddl > 57) ddl = ddl + 7;
      pszDest[i * 2] = ddh;
      pszDest[i * 2 + 1] = ddl;
   }
   pszDest[nLen * 2] = '\0';
}

//或者：
u16 Hex2StringArray (u8 *pSrc,  u16 SrcLen, u8 *pObj)
{
   u16 i=0;
   for(i=0;    i<SrcLen;   i++)
   {
      sprintf((char *)(pObj + i * 2), "%02X", *(pSrc + i));
   }
   *(pObj + i * 2) = '\0';
   return  (i * 2);
}

//（1）若带负号，代码实现：
int my_atoi(const char *str)
{
   int value = 0;
   int flag = 1; //判断符号
   while (*str == ' ')  //跳过字符串前面的空格
   {
      str++;
   }
   if (*str == '-')  //第一个字符若是‘-’，说明可能是负数
   {
      flag = 0;
      str++;
   }
   else if (*str == '+') //第一个字符若是‘+’，说明可能是正数
   {
      flag = 1;
      str++;
   }//第一个字符若不是‘+’‘-’也不是数字字符，直接返回0
   else if (*str >= '9' || *str <= '0')
   {
      return 0;
   }
   //当遇到非数字字符或遇到‘\0’时，结束转化
   while (*str != '\0' && *str <= '9' && *str >= '0')
   {
      value = value * 10 + *str - '0'; //将数字字符转为对应的整形数
      str++;
   }
   if (flag == 0) //负数的情况
   {
      value = -value;
   }
   return value;
}

//效果：字符串"-123"转为"-123"。

//（2）若不带负号，代码实现：
void StrtoDec(uint32_t *pbDest, char *pbSrc, int nLen)
{
   int i;
   int tmp=0;
   if(nLen > 10)
      *pbDest = 0;
   tmp = 1;
   *pbDest = 0;
   for (i=nLen-1; i>=0; i--)
   {
      *pbDest += tmp*(*(pbSrc+i)-'0');
      tmp = tmp*10;
   }
}

//效果：字符串"123"转为"123"。

//（3）包含转为浮点数，代码实现：
//m^n函数
//返回值:m^n次方.
u32 NMEA_Pow(u8 m,u8 n)
{
   u32 result=1;
   while(n--)result*=m;
   return result;
}
//str转换为数字,以','或者'*'结束
//buf:数字存储区
//dx:小数点位数,返回给调用函数
//返回值:转换后的数值
int NMEA_Str2num(u8 *buf,u8*dx)
{
   u8 *p=buf;
   u32 ires=0,fres=0;
   u8 ilen=0,flen=0,i;
   u8 mask=0;
   int res;
   while(1) //得到整数和小数的长度
   {
      if(*p=='-'){mask|=0X02;p++;}//是负数
      if(*p==','||(*p=='*'))break;//遇到结束了
      if(*p=='.'){mask|=0X01;p++;}//遇到小数点了
      else if(*p>'9'||(*p<'0'))   //有非法字符
      {
         ilen=0;
         flen=0;
         break;
      }
      if(mask&0X01)flen++;
     else ilen++;
     p++;
   }
   if(mask&0X02)buf++; //去掉负号
   for(i=0;i<ilen;i++) //得到整数部分数据
   {
      ires+=NMEA_Pow(10,ilen-1-i)*(buf[i]-'0');
   }
   if(flen>5)flen=5;   //最多取5位小数
   *dx=flen;           //小数点位数
   for(i=0;i<flen;i++) //得到小数部分数据
   {
      fres+=NMEA_Pow(10,flen-1-i)*(buf[ilen+1+i]-'0');
   }
   res=ires*NMEA_Pow(10,flen)+fres;
   if(mask&0X02)res=-res;
   return res;
}

//效果：字符串"123.456"先转为"123456"，然后除以1000得到"123.456"。

/*******************************************************************************
*       十进制转字符串
*   //效果：十六进制"0x13 0xAA 0x02"，转为字符串"13AAA2"。
*******************************************************************************/
u16 DectoStr (u8 *pSrc, u16 SrcLen, u8 *pObj)
{
   u16 i=0;
   for(i=0;    i<SrcLen;   i++)
   {
      sprintf((char *)(pObj + i * 2), "%02d", *(pSrc + i));
    }
    *(pObj + i * 2) = '\0';
    return  (i * 2);
}

/*******************************************************************************
//效果：十进制数组"13 14"转为字符串"1314"。

字符‘A’ ， 一个字节8bit ，即u8十六进制为0x41二进制为"0100 0001"。

而对应的十进制为65，4个字节32bit，即u32十六进制为0x41二进制为"0000 0000 0000 0000 0000 0000 0100 0001"。

（1）将u32数转换成u8数组

注意：这里是字符数组，不是字符串；字符串是以空字符(\0)结尾的char数组。
*******************************************************************************/
void U32ToU8Array(uint8_t *buf, uint32_t u32Value)
{
   buf[0] = ((u32Value >> 24) & 0xFF);
   buf[1] = ((u32Value >> 16) & 0xFF);
   buf[2] = ((u32Value >> 8) & 0xFF);
   buf[3] = (u32Value & 0xFF);
}

效果：整型 50 转字符数组 {‘\0’,’\0’,’\0’,’2’}。

//（2）u8数组转u32
//效果：字符数组 {‘\0’,’\0’,’\0’,’2’}转为整型 50。
void U8ArrayToU32(uint8_t *buf, uint32_t *u32Value)
{
   *u32Value = (buf[0] <<24) + (buf[1] <<16) + (buf[2] <<8) + (buf[3] <<0);
}


//STM32默认是小端模式，那么该如何转为大端？

//代码实现：
//为大端：
pPack[0] = (u8)((len >> 8) & 0xFF);
pPack[1] = (u8)(len & 0xFF);

//为小端：
pPack[0] = (u8)(len & 0xFF);
pPack[1] =  (u8)((len >> 8) & 0xFF);

//效果：len为数据类型为u16(short)，比如0x11 0x22，转为u8(usigned char)数组。

//大端为：
pPack[0] （0x11 ）
pPack[1] （0x22）

//小端为：
pPack[0] （0x22）
pPack[1] （0x11）
